package com.commerce.user.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

import com.commerce.common.entity.User;
import com.commerce.common.utils.PageResult;
import com.commerce.common.exception.BusinessException;
import com.commerce.user.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.commerce.common.utils.Result;
@RestController
@RequestMapping("/api/users")
@CrossOrigin
public class UserController {
    private static final Logger logger = LoggerFactory.getLogger(UserController.class);
    
    @Autowired
    private UserService userService;

    @Autowired
    private PasswordEncoder passwordEncoder;

    /**
     * 获取用户列表（仅管理员可访问）
     */
    @GetMapping
    public Result<Map<String, Object>> list(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10") Integer size) {
        try {
            // 使用安全的用户分页方法
            Page<User> pageResult = userService.getSecureUserPage(page, size);
            
            // 确保返回的用户数据不包含敏感信息
            pageResult.getRecords().forEach(user -> {
                user.setPassword(null);
                // 可以根据需要清除其他敏感字段
            });
            
            Map<String, Object> data = new HashMap<>();
            data.put("content", pageResult.getRecords());
            data.put("totalElements", pageResult.getTotal());
            
            logger.info("获取用户列表成功，页码：{}，每页大小：{}", page, size);
                
            return Result.success(data);
        } catch (BusinessException e) {
            logger.error("获取用户列表失败: {}", e.getMessage());
            return Result.error(e.getMessage());
        } catch (Exception e) {
            logger.error("获取用户列表时发生异常", e);
            return Result.error(500, "获取用户列表失败");
        }
    }

    /**
     * 删除用户
     */
    @DeleteMapping("/{id}")
    public Result<Boolean> delete(@PathVariable Long id) {
        try {
            // 获取当前用户
            User currentUser = userService.getCurrentUser();
            
            // 验证是否为管理员
            if (!"admin".equals(currentUser.getRole())) {
                logger.warn("非管理员用户 {} 尝试删除用户", currentUser.getUsername());
                return Result.error(403, "没有权限删除用户");
            }
            
            // 检查用户是否存在
            User existingUser = userService.getById(id);
            if (existingUser == null) {
                return Result.error("用户不存在");
            }
            
            return Result.success(userService.removeById(id));
        } catch (BusinessException e) {
            return Result.error(e.getMessage());
        } catch (Exception e) {
            logger.error("删除用户时发生异常", e);
            return Result.error(500, "删除用户失败");
        }
    }
    
    /**
     * 获取当前登录用户信息
     * @return 当前用户信息
     */
    @GetMapping("/current")
    public Result<User> getCurrentUser() {
        try {
            User currentUser = userService.getCurrentUser();
            if (currentUser != null) {
                // 清除敏感信息
                currentUser.setPassword(null);
                logger.info("成功获取当前用户信息: {}", currentUser.getUsername());
                return Result.success(currentUser);
            } else {
                logger.warn("未找到当前用户信息");
                return Result.error(404, "未找到当前用户信息");
            }
        } catch (BusinessException e) {
            logger.warn("获取当前用户信息失败: {}", e.getMessage());
            return Result.error(e.getMessage());
        } catch (Exception e) {
            logger.error("获取当前用户信息时发生异常", e);
            return Result.error(401, "获取当前用户信息失败");
        }
    }
    
    /**
     * 根据关键字搜索用户
     * @param keyword 搜索关键字
     * @return 匹配的用户列表
     */
    @GetMapping("/search")
    public Result<List<Map<String, Object>>> searchUsers(@RequestParam String query) {
        try {
            // 搜索用户
            LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.like(User::getUsername, query)
                    .or()
                    .like(User::getEmail, query)
                    .or()
                    .like(User::getPhone, query)
                    .last("LIMIT 20"); // 限制返回数量
            List<User> users = userService.list(queryWrapper);

            // 转换为前端需要的格式
            List<Map<String, Object>> result = new ArrayList<>();
            for (User user : users) {
                Map<String, Object> userMap = new HashMap<>();
                userMap.put("id", user.getId());
                userMap.put("username", user.getUsername());
                userMap.put("name", user.getUsername());
                userMap.put("phone", user.getPhone());
                result.add(userMap);
            }

            return Result.success(result);
        } catch (Exception e) {
            logger.error("搜索用户失败: {}", e.getMessage(), e);
            return Result.error("搜索用户失败: " + e.getMessage());
        }
    }

    /**
     * 获取用户列表（简化接口）
     */
    @GetMapping("/list")
    public Result<List<Map<String, Object>>> getUserList() {
        logger.info("获取所有用户列表");
        try {
            // 从数据库获取所有用户
            List<User> userEntities = userService.list();
            logger.info("成功从数据库获取 {} 个用户", userEntities.size());
            
            // 转换为前端需要的格式
            List<Map<String, Object>> usersList = new ArrayList<>();
            for (User user : userEntities) {
                Map<String, Object> userMap = new HashMap<>();
                userMap.put("id", user.getId());
                userMap.put("username", user.getUsername() != null ? user.getUsername() : "未命名用户");
                userMap.put("email", user.getEmail());
                userMap.put("phone", user.getPhone());
                userMap.put("role", user.getRole());
                userMap.put("createTime", user.getCreateTime() != null ? user.getCreateTime().toString() : "");
                userMap.put("icon", user.getIcon());
                userMap.put("address", user.getAddress());
                userMap.put("birthday", user.getBirthday() != null ? user.getBirthday().toString() : "");
                userMap.put("realName", user.getRealName());
                // 直接使用description字段，因为已经在实体类中配置了StringTypeHandler
                userMap.put("description", user.getDescription() != null ? user.getDescription() : "");
                usersList.add(userMap);
            }
            
            return Result.success(usersList);
        } catch (Exception e) {
            logger.error("获取用户列表失败", e);
            return Result.error(500, "获取用户列表失败: " + e.getMessage());
        }
    }
   
   @PostMapping
    public Result<Boolean> save(@RequestBody User user) {
        try {
            // 获取当前用户
            User currentUser = userService.getCurrentUser();
            
            // 验证是否为管理员
            if (!"admin".equals(currentUser.getRole())) {
                logger.warn("非管理员用户 {} 尝试创建用户", currentUser.getUsername());
                return Result.error(403, "没有权限创建用户");
            }
            
            // 验证密码是否为空
            if (user.getPassword() == null || user.getPassword().trim().isEmpty()) {
                return Result.error(400, "密码不能为空");
            }
            
            // 加密密码
            user.setPassword(passwordEncoder.encode(user.getPassword()));
            
            // 设置默认角色
            if (user.getRole() == null || user.getRole().trim().isEmpty()) {
                user.setRole("user");
            }
            
            return Result.success(userService.save(user));
        } catch (BusinessException e) {
            return Result.error(e.getMessage());
        } catch (Exception e) {
            logger.error("创建用户时发生异常", e);
            return Result.error(500, "创建用户失败");
        }
    }

    /**
     * 更新用户信息
     */
    @PutMapping("/{id}")
    public Result<User> update(@PathVariable Long id, @RequestBody User user) {
        try {
            // 检查用户是否存在
            User existingUser = userService.getById(id);
            if (existingUser == null) {
                logger.warn("用户不存在: id={}", id);
                return Result.error(404, "用户不存在");
            }
            
            // 获取当前用户
            User currentUser = userService.getCurrentUser();
            
            // 验证是否为管理员或自己的账号
            if (!"admin".equals(currentUser.getRole()) && !currentUser.getId().equals(id)) {
                logger.warn("用户 {} 尝试修改其他用户信息", currentUser.getUsername());
                return Result.error(403, "没有权限修改其他用户信息");
            }
            
            // 设置ID
            user.setId(id);
            
            // 如果更新密码，需要加密
            if (user.getPassword() != null && !user.getPassword().trim().isEmpty()) {
                user.setPassword(passwordEncoder.encode(user.getPassword()));
            } else {
                // 不更新密码，使用原密码
                user.setPassword(existingUser.getPassword());
            }
            
            // 设置更新时间
            user.setUpdateTime(LocalDateTime.now());
            
            // 更新用户
            userService.updateById(user);
            
            // 清除敏感信息
            user.setPassword(null);
            
            return Result.success(user);
        } catch (BusinessException e) {
            return Result.error(e.getMessage());
        } catch (Exception e) {
            logger.error("更新用户失败", e);
            return Result.error(500, "更新用户失败: " + e.getMessage());
        }
    }

    /**
     * 根据ID获取用户信息
     */
    @GetMapping("/{id}")
    public Result<User> getById(@PathVariable Long id) {
        logger.info("获取用户详情: id={}", id);
        
        try {
            // 从数据库查询用户
            User user = userService.getById(id);
            if (user == null) {
                logger.warn("用户不存在: id={}", id);
                return Result.error(404, "用户不存在");
            }
            
            // 清除敏感信息
            user.setPassword(null);
            
            logger.info("成功获取用户信息: username={}", user.getUsername());
            return Result.success(user);
        } catch (Exception e) {
            logger.error("获取用户详情失败", e);
            return Result.error(500, "获取用户详情失败");
        }
    }

    @GetMapping("/info")
    public Result<User> getUserInfo() {
        try {
            User user = userService.getCurrentUser();
            if (user != null) {
                // 清除敏感信息
                user.setPassword(null);
                logger.info("成功获取用户信息: {}", user.getUsername());
                return Result.success(user);
            } else {
                logger.warn("未找到用户信息");
                return Result.error(404, "未找到用户信息");
            }
        } catch (Exception e) {
            logger.error("获取用户信息失败", e);
            return Result.error(500, "获取用户信息失败：" + e.getMessage());
        }
    }

    @PutMapping("/info")
    public Result<String> updateUserInfo(@RequestBody User user) {
        try {
            userService.updateUserInfo(user);
            return Result.success("用户信息更新成功");
        } catch (Exception e) {
            logger.error("更新用户信息失败", e);
            return Result.error(500, "更新用户信息失败：" + e.getMessage());
        }
    }

    @PutMapping("/contact-info")
    public Result<String> updateContactInfo(@RequestBody Map<String, String> data) {
        try {
            User currentUser = userService.getCurrentUser();
            currentUser.setPhone(data.get("phone"));
            currentUser.setEmail(data.get("email"));
            currentUser.setAddress(data.get("address"));
            userService.updateById(currentUser);
            return Result.success("联系信息更新成功");
        } catch (Exception e) {
            logger.error("更新联系信息失败", e);
            return Result.error(500, "更新联系信息失败：" + e.getMessage());
        }
    }

    @PutMapping("/password")
    public Result<String> updatePassword(@RequestBody Map<String, String> data) {
        try {
            String oldPassword = data.get("oldPassword");
            String newPassword = data.get("newPassword");
            
            if (oldPassword == null || newPassword == null) {
                return Result.error("旧密码和新密码不能为空");
            }
            
            // 获取当前用户
            User currentUser = userService.getCurrentUser();
            if (currentUser == null) {
                return Result.error(401, "请先登录");
            }
            
            // 验证旧密码
            if (!passwordEncoder.matches(oldPassword, currentUser.getPassword())) {
                return Result.error("旧密码不正确");
            }
            
            // 更新密码
            User updateUser = new User();
            updateUser.setId(currentUser.getId());
            updateUser.setPassword(passwordEncoder.encode(newPassword));
            updateUser.setUpdateTime(LocalDateTime.now());
            
            userService.updateById(updateUser);
            
            return Result.success("密码更新成功");
        } catch (BusinessException e) {
            return Result.error(e.getMessage());
        } catch (Exception e) {
            logger.error("更新密码失败", e);
            return Result.error("更新密码失败: " + e.getMessage());
        }
    }

    /**
     * 用户注册
     */
    @PostMapping("/register")
    public Result<User> register(@RequestBody User user) {
        // 检查用户名是否已存在
        User existingUser = userService.getUserByUsername(user.getUsername());
        if (existingUser != null) {
            return Result.error("用户名已存在");
        }
        
        // 检查邮箱是否已存在
        existingUser = userService.getUserByEmail(user.getEmail());
        if (existingUser != null) {
            return Result.error("邮箱已被注册");
        }
        
        // 加密密码
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        
        // 设置注册时间和默认状态
        user.setCreateTime(LocalDateTime.now());
        user.setStatus(1); // 1: 正常状态
        
        // 保存用户
        userService.save(user);
        
        // 清除敏感信息
        user.setPassword(null);
        
        return Result.success(user);
    }

    /**
     * 分页获取用户列表
     */
    @GetMapping("/page")
    public Result<PageResult<User>> getPageList(
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "10") int size,
            @RequestParam(required = false) String username,
            @RequestParam(required = false) String email,
            @RequestParam(required = false) Integer status
    ) {
        PageResult<User> pageResult = userService.getPageList(page, size, username, email, status);
        return Result.success(pageResult);
    }
} 